package com.tbynet.jwp.service.impl;

import com.jfinal.aop.Inject;
import com.jfinal.kit.Ret;
import com.tbynet.jwp.framework.aop.Aop;
import com.tbynet.jwp.framework.core.JwpService;
import com.tbynet.jwp.service.spi.TermManager;
import com.tbynet.jwp.model.TermTaxonomy;
import com.tbynet.jwp.model.Terms;
import com.tbynet.jwp.repository.spi.TermRelationshipService;
import com.tbynet.jwp.repository.spi.TermService;
import com.tbynet.jwp.repository.spi.TermTaxonomyService;

/**
 * 分类服务编排管理类
 * @ClassName: TermManager
 * @Description: 负责分类相关业务的编排和事务管理，协调多个Service完成复杂业务操作
 * @Author: 佰亿互联
 * @Date: 2025年11月4日
 *
 * @Copyright: 2025 www.tbynet.com Inc. All rights reserved.
 * 注意: 本内容仅限于内部传阅，禁止外泄以及用于其他的商业目
 */
@Aop(TermManager.class)
public class TermServiceImpl extends JwpService implements TermManager {

    @Inject
    private TermService termService;

    @Inject
    private TermTaxonomyService termTaxonomyService;

    @Inject
    private TermRelationshipService termRelationshipService;

    /**
     * 创建分类完整业务流程
     * Manager层负责事务管理和服务编排
     * @param term 分类项
     * @param taxonomy 分类法
     * @return 操作结果
     */
    public Ret createTerm(Terms term, TermTaxonomy taxonomy) {
        log.info("开始创建分类，分类名称：{}", term.getName());

        // 参数验证
        if (term == null || taxonomy == null) {
            return buildParamError("term/taxonomy", "分类项和分类法不能为空");
        }

        if (term.getName() == null) {
            return buildParamError("name", "分类名称不能为空");
        }

        return executeInTransaction(() -> {
            try {
                // 1. 保存分类项
                if (!termService.save(term)) {
                    log.error("保存分类项失败，名称：{}", term.getName());
                    return false;
                }

                // 2. 设置分类法的分类项ID
                taxonomy.setTermId(term.getTermId());

                // 3. 保存分类法
                if (!termTaxonomyService.save(taxonomy)) {
                    log.error("保存分类法失败，分类项ID：{}", term.getTermId());
                    return false;
                }

                log.info("创建分类成功，分类ID：{}，分类法ID：{}", term.getTermId(), taxonomy.getTermTaxonomyId());
                return true;

            } catch (Exception e) {
                log.error("创建分类事务执行失败", e);
                throw new RuntimeException("创建分类事务失败", e);
            }
        }) ? buildSuccess("创建分类成功", Ret.by("termId", term.getTermId()).set("termTaxonomyId", taxonomy.getTermTaxonomyId()))
                : buildBusinessError("CREATE_TERM_FAILED", "创建分类失败");
    }

    /**
     * 更新分类完整业务流程
     * Manager层负责事务管理和服务编排
     * @param term 分类项
     * @param taxonomy 分类法
     * @return 操作结果
     */
    public Ret updateTerm(Terms term, TermTaxonomy taxonomy) {
        log.info("开始更新分类，分类ID：{}", term.getTermId());

        // 参数验证
        if (term == null || taxonomy == null || term.getTermId() == null) {
            return buildParamError("term/taxonomy", "分类项、分类法和分类ID不能为空");
        }

        return executeInTransaction(() -> {
            try {
                // 1. 更新分类项
                if (!termService.update(term)) {
                    log.error("更新分类项失败，分类ID：{}", term.getTermId());
                    return false;
                }

                // 2. 更新分类法
                if (!termTaxonomyService.update(taxonomy)) {
                    log.error("更新分类法失败，分类项ID：{}", term.getTermId());
                    return false;
                }

                log.info("更新分类成功，分类ID：{}", term.getTermId());
                return true;

            } catch (Exception e) {
                log.error("更新分类事务执行失败", e);
                throw new RuntimeException("更新分类事务失败", e);
            }
        }) ? buildSuccess("更新分类成功", null)
                : buildBusinessError("UPDATE_TERM_FAILED", "更新分类失败");
    }

    /**
     * 删除分类完整业务流程
     * Manager层负责事务管理和服务编排
     * @param termId 分类ID
     * @param taxonomy 分类法类型
     * @return 操作结果
     */
    public Ret deleteTerm(Object termId, String taxonomy) {
        log.info("开始删除分类，分类ID：{}，分类法：{}", termId, taxonomy);

        // 参数验证
        if (termId == null || taxonomy == null) {
            return buildParamError("termId/taxonomy", "分类ID和分类法类型不能为空");
        }

        return executeInTransaction(() -> {
            try {
                // 1. 获取父级
                Number parent = termTaxonomyService.getParent(termId, taxonomy);
                if (parent == null) {
                    log.error("获取分类父级失败，分类ID：{}", termId);
                    return false;
                }

                // 2. 如果有子分类，更新子分类的父级
                if (termTaxonomyService.hasChildren(termId, taxonomy)) {
                    if (!termTaxonomyService.updateChildrenParent(termId, taxonomy, parent)) {
                        log.error("更新子分类父级失败，分类ID：{}", termId);
                        return false;
                    }
                }

                // 3. 删除分类法
                if (!termTaxonomyService.deleteTermTaxonomy(termId, taxonomy)) {
                    log.error("删除分类法失败，分类ID：{}", termId);
                    return false;
                }

                // 4. 如果分类项没有其他分类法，删除分类项
                if (!termService.hasOtherTaxonomy(termId, taxonomy)) {
                    if (!termService.deleteById(termId)) {
                        log.error("删除分类项失败，分类ID：{}", termId);
                        return false;
                    }
                }

                log.info("删除分类成功，分类ID：{}", termId);
                return true;

            } catch (Exception e) {
                log.error("删除分类事务执行失败", e);
                throw new RuntimeException("删除分类事务失败", e);
            }
        }) ? buildSuccess("删除分类成功", null)
                : buildBusinessError("DELETE_TERM_FAILED", "删除分类失败");
    }

    /**
     * 为对象设置分类关系
     * @param objectId 对象ID
     * @param termId 分类项ID
     * @param taxonomy 分类法类型
     * @return 操作结果
     */
    public Ret setObjectTermRelationship(Object objectId, Object termId, String taxonomy) {
        log.info("为对象设置分类关系，objectId：{}，termId：{}，taxonomy：{}", objectId, termId, taxonomy);

        // 参数验证
        if (objectId == null || termId == null || taxonomy == null) {
            return buildParamError("objectId/termId/taxonomy", "对象ID、分类项ID和分类法类型不能为空");
        }

        try {
            // 1. 获取或创建分类法
            TermTaxonomy termTaxonomy = termTaxonomyService.getOrCreateTermTaxonomy(termId, taxonomy);
            if (termTaxonomy == null) {
                return buildBusinessError("TERM_TAXONOMY_NOT_FOUND", "分类法不存在且创建失败");
            }

            // 2. 保存分类关系
            boolean success = termRelationshipService.saveTermRelationship(objectId, termTaxonomy.getTermTaxonomyId());
            if (success) {
                log.info("设置分类关系成功，objectId：{}，termTaxonomyId：{}", objectId, termTaxonomy.getTermTaxonomyId());
                return buildSuccess("设置分类关系成功", null);
            } else {
                log.error("设置分类关系失败，objectId：{}，termTaxonomyId：{}", objectId, termTaxonomy.getTermTaxonomyId());
                return buildBusinessError("SET_RELATIONSHIP_FAILED", "设置分类关系失败");
            }

        } catch (Exception e) {
            log.error("设置分类关系异常", e);
            return buildBusinessError("SET_RELATIONSHIP_ERROR", "设置分类关系异常: " + e.getMessage());
        }
    }

    /**
     * 删除对象的分类关系
     * @param objectId 对象ID
     * @param taxonomy 分类法类型
     * @return 操作结果
     */
    public Ret removeObjectTermRelationships(Object objectId, String taxonomy) {
        log.info("删除对象的分类关系，objectId：{}，taxonomy：{}", objectId, taxonomy);

        // 参数验证
        if (objectId == null || taxonomy == null) {
            return buildParamError("objectId/taxonomy", "对象ID和分类法类型不能为空");
        }

        try {
            boolean success = termRelationshipService.deletePostTermRelationships(objectId, taxonomy);
            if (success) {
                log.info("删除分类关系成功，objectId：{}，taxonomy：{}", objectId, taxonomy);
                return buildSuccess("删除分类关系成功", null);
            } else {
                log.error("删除分类关系失败，objectId：{}，taxonomy：{}", objectId, taxonomy);
                return buildBusinessError("REMOVE_RELATIONSHIPS_FAILED", "删除分类关系失败");
            }
        } catch (Exception e) {
            log.error("删除分类关系异常", e);
            return buildBusinessError("REMOVE_RELATIONSHIPS_ERROR", "删除分类关系异常: " + e.getMessage());
        }
    }
}